CM3D2 Converter.menu_OBJECT_PT_cm3d2_menu

  1import bpy
  2import math
  3import mathutils
  4import struct
  5from . import common
  6from . import compat
  7from . import menu_file
  8
  9''' CM3D2 Menu / Object Panel Classes '''
 10
 11@compat.BlRegister()
 12class CM3D2MENU_UL_command_list(bpy.types.UIList):
 13    bl_idname      = 'CM3D2MENU_UL_command_list'
 14    bl_options     = {'DEFAULT_CLOSED'}
 15    bl_region_type = 'WINDOW'
 16    bl_space_type  = 'PROPERTIES'
 17    # The draw_item function is called for each item of the collection that is visible in the list.
 18    #   data is the RNA object containing the collection,
 19    #   item is the current drawn item of the collection,
 20    #   icon is the "computed" icon for the item (as an integer, because some objects like materials or textures
 21    #   have custom icons ID, which are not available as enum items).
 22    #   active_data is the RNA object containing the active property for the collection (i.e. integer pointing to the
 23    #   active item of the collection).
 24    #   active_propname is the name of the active property (use 'getattr(active_data, active_propname)').
 25    #   index is index of the current item in the collection.
 26    #   flt_flag is the result of the filtering process for this item.
 27    #   Note: as index and flt_flag are optional arguments, you do not have to use/declare them here if you don't
 28    #         need them.
 29    def draw_item(self, context, layout, data, item, icon, active_data, active_propname):
 30        command_prop = item.dereference(data)
 31        # draw_item must handle the three layout types... Usually 'DEFAULT' and 'COMPACT' can share the same code.
 32        if self.layout_type in {'DEFAULT', 'COMPACT'}:
 33            # You should always start your row layout by a label (icon + text), or a non-embossed text field,
 34            # this will also make the row easily selectable in the list! The later also enables ctrl-click rename.
 35            # We use icon_value of label, as our given icon is an integer value, not an enum ID.
 36            # Note "data" names should never be translated!
 37            if command_prop:
 38                command_enum_info = menu_file.get_command_enum_info(command_prop.command)
 39                icon = 'NONE'
 40                if command_enum_info:
 41                    icon = compat.icon(command_enum_info[3])
 42                layout.label(text=command_prop.name, icon=icon)
 43            else:
 44                layout.label(text="", translate=False, icon_value=icon)
 45        # 'GRID' layout type should be as compact as possible (typically a single icon!).
 46        elif self.layout_type in {'GRID'}:
 47            layout.alignment = 'CENTER'
 48            layout.label(text="", icon_value=icon)
 49
 50
 51@compat.BlRegister()
 52class OBJECT_PT_cm3d2_menu(bpy.types.Panel):
 53    bl_space_type  = 'PROPERTIES'
 54    bl_region_type = 'WINDOW'
 55    bl_context     = 'object'
 56    bl_label       = 'CM3D2 Menu'
 57    bl_idname      = 'OBJECT_PT_cm3d2_menu'
 58
 59    @classmethod
 60    def poll(cls, context):
 61        ob = context.object
 62        if ob:
 63            return True
 64        return False
 65
 66    def draw(self, context):
 67        ob = context.object
 68
 69        row = self.layout.row(align=True)
 70        row.operator('cm3d2menu.import', text="Import CM3D2 Menu File", icon=compat.icon('IMPORT'))
 71        row.operator('cm3d2menu.export', text="Export CM3D2 Menu File", icon=compat.icon('EXPORT'))
 72
 73        cm3d2_menu = ob.cm3d2_menu
 74        active_command = cm3d2_menu.get_active_command()
 75        
 76        col = self.layout.column()
 77        col.prop(cm3d2_menu, 'version'    , translate=False)
 78        col.prop(cm3d2_menu, 'path'       , translate=False)
 79        col.prop(cm3d2_menu, 'name'       , translate=False)
 80        col.prop(cm3d2_menu, 'category'   , translate=False)
 81        col.prop(cm3d2_menu, 'description', translate=False, expand=True)
 82
 83        row = self.layout.row()
 84        row.template_list('CM3D2MENU_UL_command_list', '',
 85            cm3d2_menu, 'commands'    ,
 86            cm3d2_menu, 'active_index',
 87        )
 88        sub_col = row.column(align=True)
 89        sub_col.operator('cm3d2menu.command_add'   , icon='ADD'   , text="")
 90        sub_col.operator('cm3d2menu.command_remove', icon='REMOVE', text="")
 91        #sub_col.separator()
 92        #sub_col.menu("OBJECT_MT_cm3d2_menu_context_menu", icon='DOWNARROW_HLT', text="")
 93        if active_command:
 94            sub_col.separator()
 95            sub_col.operator("cm3d2menu.command_move", icon='TRIA_UP'  , text="").direction = 'UP'  
 96            sub_col.operator("cm3d2menu.command_move", icon='TRIA_DOWN', text="").direction = 'DOWN'
 97        
 98        if active_command:
 99            box = self.layout.box()
100            if not compat.IS_LEGACY:
101                box.use_property_split = True
102            cm3d2_menu.get_active_command().draw(context, box)
103
104
105
106
107''' CM3D2 Menu Operators '''
108
109@compat.BlRegister()
110class CM3D2MENU_OT_import(bpy.types.Operator):
111    bl_idname      = 'cm3d2menu.import'
112    bl_label       = "Import CM3D2 Menu File"
113    bl_description = "Open a .menu file"
114    bl_options     = {'REGISTER', 'UNDO'}
115
116    filepath     = bpy.props.StringProperty(subtype='FILE_PATH')
117    filename_ext = '.menu'
118    filter_glob  = bpy.props.StringProperty(default='*.menu', options={'HIDDEN'})
119
120    @classmethod
121    def poll(cls, context):
122        ob = context.object
123        if ob and ob in context.editable_objects:
124            return True
125        return False
126
127    def invoke(self, context, event):  # type: (bpy.types.Context, Any) -> set
128        prefs = common.preferences()
129        if prefs.menu_import_path:
130            self.filepath = prefs.menu_import_path
131        else:
132            self.filepath = prefs.menu_default_path
133
134        context.window_manager.fileselect_add(self)
135        return {'RUNNING_MODAL'}
136
137    def execute(self, context):
138        ob = context.object
139        try:
140            file = open(self.filepath, 'rb')
141            ob.cm3d2_menu.clear()
142            ob.cm3d2_menu.unpack_from_file(file)
143        except IOError as e:
144            self.report(type={'ERROR'}, message=e.args[0])
145            return {'CANCELLED'}
146        return {'FINISHED'}
147        
148
149@compat.BlRegister()
150class CM3D2MENU_OT_export(bpy.types.Operator):
151    bl_idname      = 'cm3d2menu.export'
152    bl_label       = "Export CM3D2 Menu File"
153    bl_description = "Writes the active CM3D2Menu to a .menu file"
154    bl_options     = {'REGISTER', 'UNDO'}
155
156    filepath     = bpy.props.StringProperty(subtype='FILE_PATH')
157    filename_ext = '.menu'
158    filter_glob  = bpy.props.StringProperty(default='*.menu', options={'HIDDEN'})
159
160    is_backup = bpy.props.BoolProperty(name="Backup", default=True, description="Will backup overwritten files.")
161
162    @classmethod
163    def poll(cls, context):
164        ob = context.object
165        if ob and len(ob.cm3d2_menu.commands):
166            return True
167        return False
168
169    def invoke(self, context, event):  # type: (bpy.types.Context, Any) -> set
170        prefs = common.preferences()
171        if prefs.menu_import_path:
172            self.filepath = prefs.menu_import_path
173        else:
174            self.filepath = prefs.menu_default_path
175
176        context.window_manager.fileselect_add(self)
177        return {'RUNNING_MODAL'}
178
179    def draw(self, context):
180        box = self.layout.box()
181        box.prop(self, 'is_backup', icon='FILE_BACKUP')
182
183    def execute(self, context):
184        ob = context.object
185        try:
186            file = common.open_temporary(self.filepath, 'wb', is_backup=self.is_backup)
187            ob.cm3d2_menu.pack_into_file(file)
188        except IOError as e:
189            self.report(type={'ERROR'}, message=e.args[0])
190            return {'CANCELLED'}
191        self.report(type={'INFO'}, message="Successfully exported to .menu file")
192        return {'FINISHED'}
193
194
195@compat.BlRegister()
196class CM3D2MENU_OT_command_add(bpy.types.Operator):
197    bl_idname      = 'cm3d2menu.command_add'
198    bl_label       = "Add Command"
199    bl_description = "Adds a new CM3D2MenuCommand to the active CM3D2Menu"
200    bl_options     = {'REGISTER', 'UNDO'}
201
202    command_type_enums = menu_file.COMMAND_ENUMS.copy()
203    command_type_enums.append( ('NONE', 'Custom', 'Some other manually entered miscillaneous command', 'GREASEPENCIL', -1) )
204    type = bpy.props.EnumProperty(items=command_type_enums, name="Type", default='NONE')
205    
206    string = bpy.props.StringProperty(name="String", default="newcommand")
207
208    @classmethod
209    def poll(cls, context):
210        ob = context.object
211        if ob:
212            return True
213        return False
214
215    def invoke(self, context, event):
216        return context.window_manager.invoke_props_dialog(self)
217    
218    def draw(self, context):
219        self.layout.prop(self, 'type')
220        if self.type == 'NONE':
221            self.layout.prop(self, 'string')
222    
223    def execute(self, context):
224        ob = context.object
225        cm3d2_menu = ob.cm3d2_menu
226        if self.type != 'NONE':
227            self.string = self.type
228
229        cm3d2_menu.new_command(self.string)
230        cm3d2_menu.active_index = len(cm3d2_menu.commands) - 1
231
232        return {'FINISHED'}
233
234
235@compat.BlRegister()
236class CM3D2MENU_OT_command_remove(bpy.types.Operator):
237    bl_idname      = 'cm3d2menu.command_remove'
238    bl_label       = "Remove Command"
239    bl_description = "Removes the active CM3D2MenuCommand from the active CM3D2Menu"
240    bl_options     = {'REGISTER', 'UNDO'}
241
242    @classmethod
243    def poll(cls, context):
244        ob = context.object
245        if ob and len(ob.cm3d2_menu.commands) - ob.cm3d2_menu.active_index > 0:
246            return True
247        return False
248
249    def execute(self, context):
250        ob = context.object
251        cm3d2_menu = ob.cm3d2_menu
252        cm3d2_menu.remove_command(cm3d2_menu.active_index)
253        if cm3d2_menu.active_index >= len(cm3d2_menu.commands):
254            cm3d2_menu.active_index = len(cm3d2_menu.commands) - 1
255
256        return {'FINISHED'}
257
258
259@compat.BlRegister()
260class CM3D2MENU_OT_command_move(bpy.types.Operator):
261    bl_idname      = 'cm3d2menu.command_move'
262    bl_label       = "Move Command"
263    bl_description = "Moves the active CM3D2MenuCommand up/down in the list"
264    bl_options     = {'REGISTER', 'UNDO'}
265
266    items = [
267        ('UP'  , "Up"  , "Move the active CM3D2MenuCommand up in the list"  ),
268        ('DOWN', "Down", "Move the active CM3D2MenuCommand down in the list"),
269    ]
270    direction = bpy.props.EnumProperty(items=items, name="Direction")
271
272    @classmethod
273    def poll(cls, context):
274        ob = context.object
275        if ob and len(ob.cm3d2_menu.commands) - ob.cm3d2_menu.active_index > 0:
276            return True
277        return False
278
279    def execute(self, context):
280        ob = context.object
281        cm3d2_menu = ob.cm3d2_menu
282
283        new_index = cm3d2_menu.active_index - 1 if self.direction == 'UP' else cm3d2_menu.active_index + 1
284        if new_index >= len(cm3d2_menu.commands):
285            new_index = len(cm3d2_menu.commands) - 1
286        elif new_index < 0:
287            new_index = 0
288
289        cm3d2_menu.move_command(cm3d2_menu.active_index, new_index)
290        cm3d2_menu.active_index = new_index
291
292        return {'FINISHED'}
293
294
295
296
297''' CM3D2 Menu Command Operators '''
298
299# For menu_file.CM3D2MENU_PG_AttachPointCommand
300
301@compat.BlRegister()
302class CM3D2MENU_OT_align_selected_to_attach_point(bpy.types.Operator):
303    bl_idname      = 'cm3d2menu.align_selected_to_attach_point'
304    bl_label       = "Align Selected to Attach Point"
305    bl_description = "Align other selected objects to the active object's active CM3D2 attach point"
306    bl_options     = {'REGISTER', 'UNDO'}
307
308    scale = bpy.props.FloatProperty(name="Scale", default=5, min=0.1, max=100, soft_min=0.1, soft_max=100, step=100, precision=1, description="The amount by which the mesh is scaled when imported. Recommended that you use the same when at the time of export.")
309
310    @classmethod
311    def poll(cls, context):
312        ob = context.object
313        arm_ob = None
314        if ob.type == 'ARMATURE':
315            arm_ob = ob
316        else:
317            arm_ob = ob.find_armature()
318        if (not arm_ob) and (ob.parent and ob.parent.type == 'ARMATURE'):
319            arm_ob = ob.parent
320
321        if arm_ob and arm_ob.type == 'ARMATURE':
322            active_command = ob.cm3d2_menu.get_active_command()
323            if type(active_command) != menu_file.CM3D2MENU_PG_AttachPointCommand:
324                return False
325        
326        selection = None
327        try:
328            selection = context.selected_editable_objects
329        except:
330            return False
331
332        if not selection or len(selection) < 1:
333            return False
334
335        for selected in selection:
336            if selected != arm_ob and selected != ob:
337                return True
338
339        return False
340
341    def invoke(self, context, event):
342        self.scale = common.preferences().scale
343        return context.window_manager.invoke_props_dialog(self)
344
345    def draw(self, context):
346        self.layout.prop(self, 'scale')
347
348    def execute(self, context):
349        ob = context.object
350        if ob.type == 'ARMATURE':
351            arm_ob = ob
352        else:
353            arm_ob = ob.find_armature()
354        if (not arm_ob) and (ob.parent and ob.parent.type == 'ARMATURE'):
355            arm_ob = ob.parent
356        selection = context.selected_editable_objects
357        
358        attach_point = ob.cm3d2_menu.get_active_command()
359        attach_mat = attach_point.rotation.to_matrix().to_4x4()
360        attach_mat.translation = attach_point.location.copy() * self.scale
361
362        attach_basis = compat.convert_cm_to_bl_space(attach_mat)
363        attach_basis = compat.convert_cm_to_bl_bone_rotation(attach_basis)
364
365        for selected in selection:
366            if selected == arm_ob or selected == ob:
367                continue
368            const = selected.constraints.get("CM3D2 Attachment")
369            if not const:
370                const = selected.constraints.new("CHILD_OF")
371                const.name = "CM3D2 Attachment"
372            const.target = arm_ob
373            selected.matrix_basis = attach_basis
374    
375        return {'FINISHED'}
376
377
378@compat.BlRegister()
379class CM3D2MENU_OT_align_attach_point_to_selected(bpy.types.Operator):
380    bl_idname      = 'cm3d2menu.align_attach_point_to_selected'
381    bl_label       = "Align Attach Point to Selected"
382    bl_description = "Align the active CM3D2Menu's active attach point to the first other selected object"
383    bl_options     = {'REGISTER', 'UNDO'}
384
385    scale = bpy.props.FloatProperty(name="Scale", default=5, min=0.1, max=100, soft_min=0.1, soft_max=100, step=100, precision=1, description="The amount by which the mesh is scaled when imported. Recommended that you use the same when at the time of export.")
386
387    @classmethod
388    def poll(cls, context):
389        ob = context.object
390        arm_ob = None
391        if ob.type == 'ARMATURE':
392            arm_ob = ob
393        else:
394            arm_ob = ob.find_armature()
395        if (not arm_ob) and (ob.parent and ob.parent.type == 'ARMATURE'):
396            arm_ob = ob.parent
397
398        if arm_ob and arm_ob.type == 'ARMATURE':
399            active_command = ob.cm3d2_menu.get_active_command()
400            if type(active_command) != menu_file.CM3D2MENU_PG_AttachPointCommand:
401                return False
402        
403        selection = None
404        try:
405            selection = context.selected_objects
406        except:
407            return False
408
409        if not selection or len(selection) < 1:
410            return False
411
412        for selected in selection:
413            if selected != arm_ob and selected != ob:
414                return True
415
416        return False
417
418    def invoke(self, context, event):
419        self.scale = common.preferences().scale
420        return context.window_manager.invoke_props_dialog(self)
421
422    def draw(self, context):
423        self.layout.prop(self, 'scale')
424
425    def execute(self, context):
426        ob = context.object
427        if ob.type == 'ARMATURE':
428            arm_ob = ob
429        else:
430            arm_ob = ob.find_armature()
431        if (not arm_ob) and (ob.parent and ob.parent.type == 'ARMATURE'):
432            arm_ob = ob.parent
433        selection = context.selected_objects
434        
435        attach_point = ob.cm3d2_menu.get_active_command()
436
437
438        for selected in selection:
439            if selected == arm_ob or selected == ob:
440                continue
441            mat = compat.mul(arm_ob.matrix_world.inverted(), selected.matrix_world)
442            mat = compat.convert_bl_to_cm_space(mat)
443            mat = compat.convert_bl_to_cm_bone_rotation(mat)
444
445            attach_point.location = mat.translation * (1/self.scale)
446            attach_point.rotation = mat.to_euler()
447    
448        return {'FINISHED'}
449
450
451
452# For menu_file.CM3D2MENU_PG_MiscCommand
453
454@compat.BlRegister()
455class CM3D2MENU_OT_param_add(bpy.types.Operator):
456    bl_idname      = 'cm3d2menu.param_add'
457    bl_label       = "Add Parameter"
458    bl_description = "Adds a new CM3D2MenuParam to the active CM3D2MenuCommand"
459    bl_options     = {'REGISTER', 'UNDO'}
460
461    @classmethod
462    def poll(cls, context):
463        ob = context.object
464        if ob and ob.cm3d2_menu:
465            misc_command = ob.cm3d2_menu.get_active_command()
466            if type(misc_command) == menu_file.CM3D2MENU_PG_MiscCommand:
467                return True
468        return False
469   
470    def execute(self, context):
471        ob = context.object
472        cm3d2_menu = ob.cm3d2_menu
473        misc_command = ob.cm3d2_menu.get_active_command()
474        misc_command.new_param()
475        misc_command.active_index = len(misc_command.params) - 1
476
477        return {'FINISHED'}
478
479
480@compat.BlRegister()
481class CM3D2MENU_OT_param_remove(bpy.types.Operator):
482    bl_idname      = 'cm3d2menu.param_remove'
483    bl_label       = "Remove Parameter"
484    bl_description = "Removes the active CM3D2MenuParam from the active CM3D2MenuCommand"
485    bl_options     = {'REGISTER', 'UNDO'}
486
487    @classmethod
488    def poll(cls, context):
489        ob = context.object
490        if not ob or not ob.cm3d2_menu:
491            return False
492
493        misc_command = ob.cm3d2_menu.get_active_command()
494        if type(misc_command) != menu_file.CM3D2MENU_PG_MiscCommand:
495            return False
496        
497        if len(misc_command.params) - misc_command.active_index <= 0:
498            return False
499            
500        return True
501
502    def execute(self, context):
503        ob = context.object
504        cm3d2_menu = ob.cm3d2_menu
505        misc_command = ob.cm3d2_menu.get_active_command()
506        misc_command.remove_param(misc_command.active_index)
507        if misc_command.active_index >= len(misc_command.params):
508            misc_command.active_index = len(misc_command.params) - 1
509
510        return {'FINISHED'}
511
512
513@compat.BlRegister()
514class CM3D2MENU_OT_param_move(bpy.types.Operator):
515    bl_idname      = 'cm3d2menu.param_move'
516    bl_label       = "Move Parameter"
517    bl_description = "Moves the active CM3D2MenuParameter up/down in the list"
518    bl_options     = {'REGISTER', 'UNDO'}
519
520    items = [
521        ('UP'  , "Up"  , "Move the active CM3D2MenuCommand up in the list"  ),
522        ('DOWN', "Down", "Move the active CM3D2MenuCommand down in the list"),
523    ]
524    direction = bpy.props.EnumProperty(items=items, name="Direction")
525
526    @classmethod
527    def poll(cls, context):
528        ob = context.object
529        if not ob or not ob.cm3d2_menu:
530            return False
531
532        misc_command = ob.cm3d2_menu.get_active_command()
533        if type(misc_command) != menu_file.CM3D2MENU_PG_MiscCommand:
534            return False
535        
536        if len(misc_command.params) - misc_command.active_index <= 0:
537            return False
538
539        return True
540
541    def execute(self, context):
542        ob = context.object
543        cm3d2_menu = ob.cm3d2_menu
544        misc_command = ob.cm3d2_menu.get_active_command()
545
546        new_index = misc_command.active_index - 1 if self.direction == 'UP' else misc_command.active_index + 1
547        if new_index >= len(misc_command.params):
548            new_index = len(misc_command.params) - 1
549        elif new_index < 0:
550            new_index = 0
551
552        misc_command.move_param(misc_command.active_index, new_index)
553        misc_command.active_index = new_index
554
555        return {'FINISHED'}